package android.utility;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.json.JSONObject;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import android.widget.Toast;

/**
 * 특정 클래스에 소속되지 않는 공통 메소드를 선언합니다.
 * @author stu
 *
 */
public class Utility {

    /**
     * 천단위마다 컴마를 출력합니다.
     * @param price 금액
     * @return 컴마가 포함된 문자열
     */
    public static String comma(int price){
        DecimalFormat comma = new DecimalFormat("###,###,##0");
        String cs = comma.format(price);
        
        return cs;
    }
    
    /**
     * null 문자를 공백 문자로 변경합니다.
     * @param str 검사할 문자열
     * @return null 값을 가지고 있는 객체는 공백 문자열로 리턴됨
     */    
    public static String checkNull(String str){
        if ( str == null){
            return "";
        }else{
            return str;
        }
    }
    
    /**
     *String to byte 한글 깨짐 방지 
     */
     
    public static String stringToByte(String str){
        String deli=",";  
        String retVal = "";
        try{
            byte[] bstr = str.getBytes("UTF-8");

            for(int i=0; i< bstr.length; i++){
                retVal = retVal + deli + bstr[i];
            }
        }catch(Exception e){
            
        }
        return retVal;

    }
    /**
     * 바이트배열로 되어 있는 문자열을 받아 원래의 문자열로 변환 
     * @param str
     * @return
     */
    public static String byteToString(String str){
        String retVal = "";
        
        try{
            StringTokenizer st = new StringTokenizer(str, ",");
            byte[] _str = new byte[st.countTokens()];
            int i=-1;
            
            while(st.hasMoreTokens()){
               i++;
                _str[i] = Byte.parseByte(st.nextToken());
            }
            retVal = new String(_str, 0, _str.length, "UTF-8");
        }catch(Exception e){
            
        }

        return retVal;
    }
   
    /**
     * 주어진 문자셋의 문자코드를 변환합니다.
     * @param ko
     * @return
     */
    public static String ko(String ko){
        String corean = null;
        try{
            //corean= new String(ko.getBytes("8859_1"), "euc-kr");
            //corean= new String(ko.getBytes("8859_1"), "utf-8");
            //corean= new String(ko.getBytes("8859_1"), "iso-8859-1");
            //corean= new String(ko.getBytes("8859_1"), "utf-8");
            corean= new String(ko.getBytes("8859_1"), "KSC5601");
        }catch(Exception e){
            return corean; 
        }
        return corean;
    }
    
    /**
     * 오늘 날짜를 문자열로 리턴합니다.
     * @return
     */
    public static String getCalendarDay(){
        String str="";
        Calendar cal = Calendar.getInstance();
        str = "" + cal.get(Calendar.DATE); //날짜
        
        return str;
    }

    /**
     * yyyy-mm-dd 형식의 날짜를 리턴합니다.
     * @return 2008-01-30 형식의 문자열 리턴
     */
    public static String getDate(){
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
        
        String date = sd.format(new Date());

        // System.out.println(date);        
        return date;
    }
    
    /**
     * 내용중에 특수문자 표현을 위해 HTML 특수문자로 변환합니다.
     */
    public static String getConvertChar(String str){
        for(int i=0; i < str.length(); i++){
            if(str.charAt(i) =='<'){
                str=str.substring(0, i) + "&lt;" + str.substring(i+1, str.length());
                i=i+4; //1자가 3자로 변환됨으로 +4을 합니다.
            }else if(str.charAt(i) == '>'){
                str=str.substring(0, i) + "&gt;" + str.substring(i+1, str.length());
                i=i+4;
            }else if(str.charAt(i) == '&'){
                str=str.substring(0, i) + "&amp;" + str.substring(i+1, str.length());
                i=i+5;
            }else if(str.charAt(i) == ' '){
                str=str.substring(0, i) + "&nbsp;" + str.substring(i+1, str.length());
                i=i+6;
            }
        }
        return str;
    }

    /**
     * 내용중에 특수문자 표현을 위해 HTML 특수문자로 변환합니다.
     */
    public static String getConvertBR(String str){
        return str.replace("\n", "<BR>");
    }

    /**
     * 파일 Download시 한글 파일 인코딩
     * @param str
     * @return
     */
    public static String getEncoding(String str){
        try{
        //resin UTF-8 로 지정
            //str = java.net.URLEncoder.encode(str, "EUC-KR");
            //str = java.net.URLEncoder.encode(str, "UTF-8");
            str = java.net.URLEncoder.encode(str, "KSC5601");
        }catch(Exception e){
        
        }

        //System.out.println(str);

        for(int i=0; i < str.length(); i++){
            if(str.charAt(i) =='+'){
                str=str.substring(0, i) + "%20" + str.substring(i+1, str.length());
                i=i+3;
            }
        }
        //System.out.println("최종변환 형태: "+str);
        return str;
    }    

    /**
     * Ajax 한글 변환
     * @param ko
     * @return
     */
    public static String koAjax(String ko){
        String corean = null;
        try{
            // corean= new String(ko.getBytes("ISO-8859-1"), "UTF-8");
            corean= new String(ko.getBytes("KSC5601"), "EUC-KR");
        }catch(Exception e){
            return corean; 
        }
        return corean;
    }
    
    /**
     * 자바스크립트 특수문자, 줄바꿈 문자 변환
     * @param str
     * @return
     */
    public static String toJS(String str) {
        if (str != null){
            return str.replace("\\", "\\\\")
            .replace("\'", "\\\'")
            .replace("\"", "\\\"")
            .replace("\r\n", "\\n")
            .replace("\n", "\\n");
            
        }else{
            return "";
        }
    }  

    /**
     * 현재 날짜와 시간을 가져옵니다.
     * @return
     */
    public static String getDateTime(){
        return new Date().toLocaleString().substring(0, 22);
    }  
 
    public static void logi(String tag, String str){
        Log.i(tag, tag + " - " + str);
    }    

    public static void logd(String tag, String str){
        Log.d(tag, tag + " - " + str);
    }    

    /**
     * Ajax 한글 변환
     * @param ko
     * @return
     */
    public static String koAndroid(String ko){
        String corean = null;
        try{
            // corean= new String(ko.getBytes("UTF-8"), "EUC-KR");
            // corean= new String(ko.getBytes("ISO-8859-1"), "UTF-8");
            // corean= new String(ko.getBytes("KSC5601"), "EUC-KR");
            corean= new String(ko.getBytes("8859_1"), "UTF-8");
        }catch(Exception e){
            return corean; 
        }
        return corean;
    }
    
    public static void charsetTest(String s){
        try{
           String [] charset = {"EUC-KR", "KSC5601", "ISO-8859-1", "8859_1", "ASCII", "UTF-8", "MS949", "UTF-16"};
           for(int i=0; i<charset.length; i++)
           {
              for(int j=0; j<charset.length; j++)
              {
                 if(i==j) continue;
                 logi("Test", charset[i] + " -> " + charset[j] + " : " + new String(s.getBytes(charset[i]), charset[j]));
              }
           }
        }
        catch(Exception e){
           e.printStackTrace();
        }
     }    
    
    public static int strToInt(String str){
        return new Integer(str).intValue();
    }
    
    public static File SDCardFound(){
        File sdDir = null;                   // 폴더명 
        
        // 외장 Galaxy S 2.2
        sdDir = new File("/sdcard/external_sd");
        if (sdDir.exists() && sdDir.canWrite()){  
           sdDir = new File("/sdcard/external_sd");
           return sdDir;
        }
        
        // 외장 Galaxy S 2.1
        sdDir = new File("/sdcard/sd");
        if (sdDir.exists() && sdDir.canWrite()){  
           sdDir = new File("/sdcard/sd");
           return sdDir;
        }
        
        // General SD Card mount, 내장 Galaxy S 2.2
        sdDir = new File("/sdcard");
        if (sdDir.exists() && sdDir.canWrite()){  
           sdDir = new File("/sdcard");
           return sdDir;
        }
        
        return sdDir;
    }
    
    /**
     * 문자열 경로를 받아 모든 파일 목록을 리턴 
     * @param dir
     * @return
     */
    public static String[] fileNameList(String dir){
        File sdDir = null;
        String[] str = null;
            
        try{
            // Check SD Card mount.
            sdDir = SDCardFound();  // /sdcard
            // 존재/쓰기 여부 확인
            if (sdDir.exists() && sdDir.canWrite()){
                File _dir = new File(dir);
                if (_dir.exists() && _dir.canRead()){
                    str = _dir.list();
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        
        return str;
    }

    /**
     * 문자열 경로, 파일 확장자를 받아 파일 목록을 리턴 
     * @param dir
     * @return
     */
    public static String[] fileNameList(String dir, String _ext){
        File sdDir = null;
        String[] str = null;
        OnlyExt ext = new OnlyExt(_ext);
        
        try{
            // Check SD Card mount.
            sdDir = SDCardFound();  // /sdcard
            // 존재/쓰기 여부 확인
            if (sdDir.exists() && sdDir.canWrite()){
                File _dir = new File(dir);
                if (_dir.exists() && _dir.canRead()){
                    str = _dir.list(ext);
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        
        return str;
    }
    
    /**
     * 파일 객체를 받아 파일 목록을 리턴 
     * @param dir
     * @return
     */
    public static String[] fileNameList(File dir){
        String[] str = null;
            
        try{
                str = dir.list();
        }catch(Exception e){
            e.printStackTrace();
        }
        
        return str;
    }    
    
    /**
     * 파일 확장자를 받아 필터링후 출력 
     * @param dir
     * @param _ext
     * @return
     */
    public static String[] fileNameList(File dir, String _ext){
        String[] str = null;
        OnlyExt ext = new OnlyExt(_ext);
        
        try{
                str = dir.list(ext);
        }catch(Exception e){
            e.printStackTrace();
        }
        
        return str;
    }    
    
    public static ArrayList<String> convertFilenameNotExtend(String[] str){
        ArrayList<String> retVal = new ArrayList<String>();;
        
        for(int i=0; i< str.length; i++){
            int point = str[i].indexOf(".");
            retVal.add(str[i].substring(0, point));
        }
        
        return retVal;
    }
    
    /**
     * 외장 메모리 검색 
     * @return
     */
    public static String SDCardFoundStr(){
        File sdDir = null;                   // 폴더명
        String str = "";

        // 외장 Galaxy S 2.2
        sdDir = new File("/sdcard/external_sd");
        if (sdDir.exists() && sdDir.canWrite()){  
            str = "/sdcard/external_sd";
            return str;
        }
        
        // 외장 Galaxy S 2.1
        sdDir = new File("/sdcard/sd");
        if (sdDir.exists() && sdDir.canWrite()){  
            str = "/sdcard/sd";
            return str;
        }
        
        // General SD Card mount, 내장  Galaxy S 2.2
        sdDir = new File("/sdcard");
        if (sdDir.exists() && sdDir.canWrite()){  
           str = "/sdcard";
           return str;
        }
        
        return str;
    }

    /**
     * 외장 메모리를 검색하나 Galaxy S 2.2는 내장 메모리 검색 
     * @return
     */
    public static String SDCardFoundInOutStr(){
        File sdDir = null;                   // 폴더명
        String str = "";

        // 외장 Galaxy S 2.1
        sdDir = new File("/sdcard/sd");
        if (sdDir.exists() && sdDir.canWrite()){  
            str = "/sdcard/sd";
            return str;
        }

        // General SD Card mount, 내장 Galaxy S 2.2
        sdDir = new File("/sdcard");
        if (sdDir.exists() && sdDir.canWrite()){  
           str = "/sdcard";
           return str;
        }

        return str;
    }

    /**
     * 안드로이드 프로젝트 2조 폴더 생성
     */
    public static void makeFolder() {
        File dir = new File("/sdcard");
        File funple = new File(dir.toString() + "/piano");
        File thumbnail = new File(funple.toString() + "/piano/thumbnail");
        File nomedia = new File(funple.toString() + "/.nomedia");
        File nomedia2 = new File(thumbnail.toString() + "/.nomedia");
        if (dir.exists() && dir.canWrite()){
            try {
                funple.mkdir();
                thumbnail.mkdir();
                nomedia.createNewFile();
                nomedia2.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 기본 폴더 생성
     * @param _dir
     */
    public static void makeFolder(String _dir) {
        File sdDir = null;
        File dir = null;
        
        sdDir = SDCardFound();
        dir = new File(sdDir.toString() + "/" + _dir);
        
        if (sdDir.exists() && sdDir.canWrite()){  
           if (dir.exists() == false){
               dir.mkdir();
           }
        }
    }
    
    /**
     * 카메라 경로 추출
     * @return
     */
    public static String CameraFoundStr(){
        File sdDir = null;                   // 폴더명
        String str = "";

        // 외장 Galaxy S 2.2, 내장 SD
        sdDir = new File("/sdcard/DCIM/Camera");
        if (sdDir.exists() && sdDir.canWrite()){  
            str = "/sdcard/DCIM/Camera";
            return str;
        }

        // 외장 Galaxy S 2.1
        sdDir = new File("/sdcard/sd");
        if (sdDir.exists() && sdDir.canWrite()){  
            str = "/sdcard/sd";
            return str;
        }
        
        // General SD Card mount, 내장  Galaxy S 2.2
        sdDir = new File("/sdcard/DCIM/Camera");
        if (sdDir.exists() && sdDir.canWrite()){  
           str = "/sdcard/DCIM/Camera";
           return str;
        }
        
        return str;
    }
    
    /**
     * 주어진 URL의 HTML 로딩 
     * @param addr 로딩할 주소 
     * @return 로딩되어 생성된 BufferedReader 객체
     */
   
    public static BufferedReader loadHTML(String addr) {
        InputStream in = null;
        BufferedReader br = null;
        
        try {
            URL url = new URL(addr);
            HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection();
            if (httpConnection != null) {
                httpConnection.setConnectTimeout(10000); // 10초
                httpConnection.setUseCaches(false);
                if (httpConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                    in = httpConnection.getInputStream();
                    br = new BufferedReader(new InputStreamReader(in));
                }
            }
        } 
        catch (Exception e) {
            Log.i("Test", "loadHtml", e);
        }
        
        return br;
    }
    
    public static BufferedReader loadHtml_(String addr){
    	BufferedReader bufferedReader = null;
    	DefaultHttpClient client = new DefaultHttpClient();
    	try{
    		HttpPost post = new HttpPost(addr);
    		
    		HttpParams params = client.getParams();
    		HttpConnectionParams.setConnectionTimeout(params, 1000);
    		HttpConnectionParams.setSoTimeout(params, 3000);
    		
    		HttpResponse response = client.execute(post);
    		bufferedReader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(),"utf-8"));
    		
//    		String line = null;
//    		while((line = bufferedReader.readLine()) != null){
//    			result += line;
//    		}
    		
    	}catch(Exception e){
    		e.printStackTrace();
    		client.getConnectionManager().shutdown();
    	}
        
        return bufferedReader;
    }

    public static Bitmap getBitmap(String fname, int width, int height){
        try {
            File f = new File(fname);
            
            //Decode image size
            BitmapFactory.Options o = new BitmapFactory.Options();
            o.inJustDecodeBounds = true;
            BitmapFactory.decodeStream(new FileInputStream(f),null,o);

            //Find the correct scale value. It should be the power of 2.
            int width_tmp=o.outWidth, height_tmp=o.outHeight;
            int scale=1;
            while(true){
                if(width_tmp/2<width || height_tmp/2<height){
                    break;
                }
                width_tmp = width_tmp / 2;
                height_tmp = height_tmp / 2;
                scale = scale * 2;
            }

            //Decode with inSampleSize
            BitmapFactory.Options o2 = new BitmapFactory.Options();
            o2.inSampleSize=scale;
            return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
        } catch (FileNotFoundException e) {}
        return null;
    }
    
    /**
     * 날짜로 파일명을 받아온다.
     * @return 파일명 리턴
     */
    public static String fndate() {
        Calendar cal = Calendar.getInstance();
        
        String filename = String.format("%04d%02d%02d_%02d%02d%02d",
                cal.get(Calendar.YEAR),
                (cal.get(Calendar.MONTH) + 1),
                cal.get(Calendar.DAY_OF_MONTH),
                cal.get(Calendar.HOUR_OF_DAY),
                cal.get(Calendar.MINUTE),
                cal.get(Calendar.SECOND)
            );
        return filename;
    }
    
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static Map delete(String addr){
        Map map = new HashMap();
        StringBuilder html = new StringBuilder(); 
        
        try {
            URL url = new URL(addr);
            HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection();
            if (httpConnection != null) {
                httpConnection.setConnectTimeout(5000);
                httpConnection.setUseCaches(false);
                if (httpConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                    InputStream in = httpConnection.getInputStream();
                    
                    BufferedReader br = new BufferedReader(new InputStreamReader(in));
                    while (true) {
                        String line = br.readLine();
                        if (line == null) break;
                        html.append(line + '\n'); 
                    }
                    br.close();

                    JSONObject obj = new JSONObject(html.toString());
                    map.put("code", obj.getString("code"));
                    map.put("message", obj.getString("message"));
                }
            }                   
        } 
        catch (Exception e) {
            Log.i("Test", "loadHtml", e);
        }
        
        return map;
    }
    
    /**
     * SDCard 상에서 이미지를 로딩합니다.
     * @param addr
     * @return
     */
    public static Bitmap getSDCardImage(String addr){
        Bitmap bt = null;
        
        try {    
            // 네트웍 연결
            File f = new File(addr);
            FileInputStream fis = new FileInputStream(f);
            bt = BitmapFactory.decodeStream(fis);    // 이미지 로딩 
            
            fis.close();
      
        } catch (Exception e) {
            Log.d("D", "Image Loading...", e);
        }
        
        return bt;
    }  
    
    public static void httpFileUpload(String urlString, String fileName) {   ///fileName :sdcard/DCIM/Camera/20110128_174600.jpg
       // Log.d("D", "httpFileUpload loading.");

        HttpURLConnection conn = null;

        // ******************************************************
        // CLIENT REQUEST
        // ******************************************************

        try {
           // Log.d("D", "*** CLIENT REQUEST ***");

            String lineEnd = "\r\n";
            String twoHyphens = "--";
            String boundary = "*****";

            // Open a URL connection to the Server
            URL url = new URL(urlString);

            // Open a HTTP connection to the URL
            conn = (HttpURLConnection) url.openConnection();

            conn.setDoInput(true);     // Allow Inputs
            conn.setDoOutput(true);    // Allow Outputs
            conn.setUseCaches(false); // Don't use a cached copy.

            // Use a Post Method.
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Connection", "Keep-Alive");
            conn.setRequestProperty( "Content-Type", "multipart/form-data;boundary=" + boundary);

            // Write Data
            OutputStream os = conn.getOutputStream();
            DataOutputStream dos = new DataOutputStream(os);
            dos.writeBytes(twoHyphens + boundary + lineEnd);
            
            //전송할 파일 정보를 미리 전송
            //file1:태그명
//            //filename: 전송할 파일명
//            String fname = fileName + "/" + i;
            dos.writeBytes( "Content-Disposition: form-data; name=\"file1\";filename=\"" + fileName + "\"" + lineEnd);
            dos.writeBytes(lineEnd);
          //  dos.writeBytes("Content-Disposition: form-data; name=\"file1\";filename=\"camera.jpg\"" + lineEnd);
           // Log.d("D", "Headers are written");
            // Log.d("D", "util_fileName :" +fileName); //   /sdcard/ScreenCapture/SC20110115-171645.png

            // Read File : 파일전송
            FileInputStream fis = new FileInputStream(fileName);

            int bytesAvailable = fis.available();
            int maxBufferSize = 1024*1024;
            int bufferSize = Math.min(bytesAvailable, maxBufferSize);
            byte[] buffer = new byte[bufferSize];
            int bytesRead = fis.read(buffer, 0, bufferSize);
           // Log.d("D", "File Size is " + bytesRead);

            // Read File and Write it into Form
            while (bytesRead > 0) {
                dos.write(buffer, 0, bufferSize);

                bytesAvailable = fis.available();
                bufferSize = Math.min(bytesAvailable, maxBufferSize);
                bytesRead = fis.read(buffer, 0, bufferSize);
               }

            // Send Multipart Form Data necesssary after file data
            dos.writeBytes(lineEnd);
            dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);

            // Close streams
            fis.close();
            dos.flush(); // finish upload...
            dos.close();

           // Log.d("D", "File is written");

            // ******************************************************
            // SERVER RESPONSE
            // ******************************************************

            try {
              //  Log.d("D", "*** SERVER RESPONSE ***");

                int ch;
                InputStream is = conn.getInputStream();
                StringBuffer buf = new StringBuffer();

                while( ( ch = is.read() ) != -1 ) {
                    buf.append( (char)ch );
                }

                String strResult = buf.toString();
               // Log.d("D", "strResult:" + strResult);

            } catch (IOException e) {
                Log.d("D", "Exception : " + e.getMessage());
            }
        } catch (IOException e) {
            Log.d("D", "Exception : " + e.getMessage());
        }

    }
    
    
   
    /**
     * 20101214_1245 리턴합니다.
     * @param _date
     * @return
     */
    public static String fileDate(){
        Calendar cal = Calendar.getInstance( );


        String filename = String.format("%04d%02d%02d_%02d%02d%02d",
                                     cal.get(Calendar.YEAR),
                                     (cal.get(Calendar.MONTH) + 1),
                                     cal.get(Calendar.DAY_OF_MONTH),

                                     cal.get(Calendar.HOUR_OF_DAY),
                                     cal.get(Calendar.MINUTE)
                                 );
        // System.out.println(date);        
        return filename;
    }
    
    /**
     * 20101214_124553 리턴합니다.
     * @param _date
     * @return
     */
    public static String getCurDate(){
        Calendar cal = Calendar.getInstance( );


        String filename = String.format("%04d%02d%02d_%02d%02d%02d",
                                     cal.get(Calendar.YEAR),
                                     (cal.get(Calendar.MONTH) + 1),
                                     cal.get(Calendar.DAY_OF_MONTH),

                                     cal.get(Calendar.HOUR_OF_DAY),
                                     cal.get(Calendar.MINUTE),
                                     cal.get(Calendar.SECOND)
                                 );
        // System.out.println(date);        
        return filename;
    }
    
    
    public static Bitmap getBitmap(String addr){
        Bitmap bt = null;
        
        try {    
            // 네트웍 연결
            File f = new File(addr);
            FileInputStream fis = new FileInputStream(f);
            bt = BitmapFactory.decodeStream(fis);    // 이미지 로딩 
            Log.d("D", "bit.hashCode(): " + bt.hashCode());
            
            fis.close();
      
        } catch (Exception e) {
            Log.d("D", "Image Loading...", e);
        }
        
        return bt;
    }  
    
}

class OnlyExt implements FilenameFilter {
    String ext;
    public OnlyExt(String ext) {
        ext = ext.toLowerCase();
        
        this.ext = "." + ext;
    }
    @Override
	public boolean accept(File dir, String name) {
        return name.endsWith(ext);
    }
}




